﻿using System;
using System.Collections.Generic;
using NUnit.Framework;
using Studio7i.CapaDominio;
using Studio7i.CapaPersistencia.DAO;
using Studio7i.CapaPersistencia;



namespace Studio7i.CapaPruebas
{

    [TestFixture]
    public class Test_ServicioDAO
    {
        private IServicioDAO servDAO = null;
        private int codigoGenerado = 0;

        [TestFixtureSetUp]
        public void PrepararPruebas()
        {
            //servaciamos el DAO
            servDAO = new ServicioDAO();

            //eliminamos los Servicios que hubieran en la BD
            //foreach (Servicio serv1 in servDAO.ListarTodos())
            //    servDAO.Eliminar(serv1);

            //creamos 3 Servicios para pruebas
            foreach (Servicio i in servDAO.ListarTodos()) servDAO.Eliminar(i);
            servDAO.Crear(new Servicio() { nombre = "Grabación de CD", descripcion = "Graba tu propio CD", costoServicio = 15 });
            servDAO.Crear(new Servicio() { nombre = "Cantante Profesional", costoServicio = 180, descripcion = "Servicios de un cantante profesional" });
            servDAO.Crear(new Servicio() { nombre = "Arreglos", costoServicio = 210, descripcion = "Contratación de un arreglista profesional" });

        }
        /**********************************************************************************************************/

        [Test]
        public void Test_Crear()
        {
            Assert.IsNotNull(servDAO);
            Servicio servACrear = new Servicio();
            servACrear.nombre = "Remasterización";
            servACrear.costoServicio = 120;
            servACrear.descripcion = "Remasterizamos tus cintas";

            Servicio servCreado = null;

            // Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                servCreado = servDAO.Crear(servACrear);
                codigoGenerado = servCreado.codigo;
            }, "local creado");

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(servCreado);

            // Probamos que el código generado sea mayor a 0
            Assert.GreaterOrEqual(servCreado.codigo, 0);

            // Probamos que el nombre registrado es igual al solicitado con la entidad
            Assert.AreEqual(servCreado.nombre, servACrear.nombre);

        }
        /**********************************************************************************************************/

        [Test]
        public void Test_Obtener()
        {
            int codigo = codigoGenerado;
            Assert.IsNotNull(servDAO);

            Servicio servObtenido = null;
            // Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                servObtenido = servDAO.Obtener(codigo);
            });

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(servObtenido);

            Assert.AreEqual(servObtenido.codigo, codigo);
            Assert.IsNotNullOrEmpty(servObtenido.nombre);
            Assert.IsNotNull(servObtenido.costoServicio);
            Assert.IsNotNullOrEmpty(servObtenido.descripcion);

        }
        /**********************************************************************************************************/

        [Test]
        public void Test_Modificar()
        {
            //Assert.IsNotNull(servDAO);
            codigoGenerado = 1;
            // Declaramos e servanciamos la entidad de dominio
            Servicio servAModificar = servDAO.Obtener(codigoGenerado);
            servAModificar.codigo = codigoGenerado;
            servAModificar.nombre = "Remasterización";
            servAModificar.costoServicio = 120;
            servAModificar.descripcion = "Remasterizamos tus cintas";

            // Declaramos la entidad que contendrá el resultado
            Servicio servModificado = null;

            // Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                servModificado = servDAO.Modificar(servAModificar);
            }, "Servicio modificado");

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(servModificado);

            // Probamos que el código generado sea mayor a 0
            Assert.Greater(servModificado.codigo, 0);
        }

        /**********************************************************************************************************/
        [Test]
        public void Test_Eliminar()
        {
            Assert.IsNotNull(servDAO);

            // Definimos la entidad que contendrá el resultado
            Servicio servExistente = servDAO.Obtener(2);//(codigoGenerado);

            // Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                servDAO.Eliminar(servExistente);
            });

            // Probamos que la entidad ya no existe
            Assert.IsNull(servDAO.Obtener(2));
        }
        /**********************************************************************************************************/
        [Test]
        public void Test_ListarTodos()
        {
            Assert.IsNotNull(servDAO);
            ICollection<Servicio> servEncontrados = null;

            // 3. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                servEncontrados = servDAO.ListarTodos();
            }, "local eliminado");

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(servEncontrados);

            // Probamos que la cantidad de Servicios encontrados sea 
            Assert.GreaterOrEqual(servEncontrados.Count, 2);

            // Probamos que cada local contenga la cadena de búsqueda en su nombre
            foreach (Servicio servEncontrado in servEncontrados)
            {
                Assert.IsNotNull(servEncontrado);
                Assert.IsInstanceOf(typeof(Servicio), servEncontrado);
            }
        }
        /**********************************************************************************************************/
        [Test]
        public void Test_ListarXnombre()
        {
            Assert.IsNotNull(servDAO);
            string busqueda = "aba"; // Grabación de CD
            ICollection<Servicio> servEncontrados = null;

            //Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                servEncontrados = servDAO.ListarXNombre(busqueda);
            });

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(servEncontrados);

            // Probamos que la cantidad de locales encontrados sea 
            Assert.AreEqual(servEncontrados.Count, 1);

            // Probamos que cada serv contenga la cadena de búsqueda en su nombre
            foreach (Servicio servEncontrado in servEncontrados)
            {
                Assert.IsTrue(servEncontrado.nombre.Contains(busqueda));
            }
        }
    }
}
